My code won't tweet from the file every interval, it only prints in the terminal, but not on twitter. I'm also trying to loop it so that once done with the file.length its repeats. Thanks for your help.
require 'Twitter'
client = Twitter::REST::Client.new do |config|
config.consumer_key = "..."
config.consumer_secret = "..."
config.access_token = "..."
config.access_token_secret = "..."
end
blog_post = []
tweet_img = []
def post
File.open("tweets.txt") do rand |line|
line.each do |item|
tweets = item.chomp.split("\n")
#while client.update("#{}")
puts tweets
sleep(30)
#end
#puts blog_post.to_s, "\n\n"
end
end
end
puts client.update("#{post}").text
require 'Twitter'
OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
client = Twitter::REST::Client.new do |config|
config.consumer_key = "xxxx"
config.consumer_secret = "xxxx"
config.access_token = "xxxx"
config.access_token_secret = "xxxx"
end
file = File.open("tweets.txt")
ary = []
i = 0
file.each_line do |line|
ary[i] = line.chomp
i += 1
end
file.close
j = 0
i.times do
client.update("#{ary[j]}")
j += 1
sleep 10
end
Your call to Twitter:
client.update("#{post}").text
is outside of your loop, so it is only called once. If you want it for each line, it should be:
def post
File.open("tweets.txt") do rand |line|
line.each do |item|
tweets = item.chomp.split("\n")
puts tweets
client.update("#{tweets}").text
sleep(30)
end
end
end
Related
How can i create WSS client connection in JRuby framework?
i am using faye/websocket-driver-ruby gem for connecting and publishing message, can anyone provide the imformation about this.
Getting error,
IOError: Connection reset by peer
sysread at org/jruby/ext/openssl/SSLSocket.java:857,
Please let me know what i am doing wrong.
require 'bundler/setup'
require 'eventmachine'
require 'websocket/driver'
require 'permessage_deflate'
require 'socket'
require 'uri'
require "openssl"
class WSSClient
DEFAULT_PORTS = { 'ws' => 80, 'wss' => 443 }
attr_reader :url, :thread
def initialize
#url = "wss://localhost:433/wss"
#uri = URI.parse(#url)
#port = #uri.port || DEFAULT_PORTS[#uri.scheme]
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
#socket = TCPSocket.new(#uri.host, #port)
ssl_context.ssl_version = :TLSv1_2_client
ssl_socket = OpenSSL::SSL::SSLSocket.new(#socket, ssl_context)
ssl_socket.sync_close = true
ssl_socket.connect
#driver = WebSocket::Driver.client(self)
#driver.add_extension(PermessageDeflate)
str = "Hello server!"
str = str + "\n"
#dead = false
#driver.on(:open) { |event| write str }
#driver.on(:message) { |event| p [:message, event.data] }
#driver.on(:close) { |event| finalize(event) }
#thread = Thread.new do
#driver.parse(ssl_socket.read(1)) until #dead
end
#driver.start
end
def send(message)
#driver.text(message)
end
def write(data)
ssl_socket.write(data)
end
def close
#driver.close
end
def finalize(event)
p [:close, event.code, event.reason]
#dead = true
#thread.kill
end
end
Or any other way (algorithm) to create WSS client.
I'm pulling tweets from a text file and tweeting them in timed intervals. As the first tweet is posted, everything is fine. When its time for the next tweet to post I get an error that reads:
I got my four keys, but I can always renew them or get new ones...Here is the code I'm using:
require 'Twitter'
client = Twitter::REST::Client.new do |config|
config.consumer_key = "..."
config.consumer_secret = "..."
config.access_token = "..."
config.access_token_secret = "..."
end
def repeat_every(interval)
loop do
start_time = Time.now
yield
elapsed = Time.now - start_time
sleep([interval - elapsed, 0].max)
end
end
blog_post = []
tweet_img = []
def post
client = Twitter::REST::Client.new do |config|
config.consumer_key = "..."
config.consumer_secret = "..."
config.access_token = "..."
config.access_token_secret = "..."
end
File.open("tweets.txt") do |line|
line.each do |item|
tweets = item
puts tweets
client.update("#{tweets}").to_s
sleep((rand*1800 +900).to_i)
end
end
end
repeat_every(81000){
post
}
require 'Twitter'
def repeat_every(interval)
loop do
start_time = Time.now
yield
elapsed = Time.now - start_time
sleep([interval - elapsed, 0].max)
end
end
def post
client = Twitter::REST::Client.new do |config|
config.consumer_key = "xxxx"
config.consumer_secret = "xxxx"
config.access_token = "xxxx"
config.access_token_secret = "xxxx"
end
File.open("tweets.txt") do |line|
line.each_line do |item|
tweets = item
puts tweets
client.update("#{tweets}")
sleep((rand*10 + 10).to_i)
end
end
end
repeat_every(81000){
post
}
insert this code on the second line
OpenSSL :: SSL :: VERIFY_PEER = OpenSSL :: SSL :: VERIFY_NONE
I'm trying to write a class "web" in Ruby 2.0.0 that inherits from GEXF::Graph, but I am unable to get the Graph methods like Web.define_node_attribute to work. I'm a new ruby programmer, so I expect I'm doing something goofy. Thanks.
webrun.rb
require 'rubygems'
require 'gexf'
require 'anemone'
require 'mechanize'
require_relative 'web'
web = Web.new
web.define_node_attribute(:url)
web.define_node_attribute(:links,
:type => GEXF::Attribute::BOOLEAN,
:default => true)
web.rb
require 'rubygems'
require 'gexf'
require 'anemone'
require 'mechanize'
class Web < GEXF::Graph
attr_accessor :root
attr_accessor :pages
def initialize
#pages = Array.new
end
def pages
#pages
end
def add page
#pages << page
end
def parse uri, protocol = 'http:', domain = 'localhost', file = 'index.html'
u = uri.split('/')
if n = /^(https?:)/.match(u[0])
protocol = n[0]
u.shift()
end
if u[0] == ''
u.shift()
end
if n = /([\w\.]+\.(org|com|net))/.match(u[0])
domain = n[0]
u.shift()
end
if n = /(.*\.(html?|gif))/.match(u[-1])
file = n[0]
u.pop()
end
cnt = 0
while u[cnt] == '..' do
cnt = cnt + 1
u.shift()
end
while cnt > 0 do
cnt = cnt - 1
u.shift()
end
directory = '/'+u.join('/')
puts "protocol: " + protocol + " domain: " + domain + \
" directory: " + directory + " file: " + file
protocol + "//" + domain + directory + (directory[-1] == '/' ? '/' : '') + file
end
def crawl
Anemone.crawl(#root) do |anemone|
anemone.on_every_page do |sitepage|
add sitepage
end
end
end
def save file
f = File.open(file, mode = "w")
f.write(to_xml)
f.close()
end
end
The issue is that you are monkey-patching the GEXF::Graph initialize method without calling super on it. What you did was essentially 'write-over' the initialize method that needed to be called. To fix this, change your initialize method to call the super method first:
def initialize
super
#pages = Array.new
end
I have written a small Sinatra script to fetch 2 tweets of a user and display 10 retweeters in the descending order of their no. of followers:
Puzzle/puzzle.rb
require 'twitter'
require 'json'
require 'sinatra'
#require 'haml'
client = Twitter::REST::Client.new do |config|
config.consumer_key = ""
config.consumer_secret = ""
config.access_token = ""
config.access_token_secret = ""
end
set :server, 'webrick'
set :haml, :format => :html5
get '/' do
content_type :json
arr = []
retweeters = client.retweeters_of(429627812459593728)
retweeters.each do |retweeter|
ob = {}
ob[:name] = retweeter.name
ob[:followers_count] = retweeter.followers_count
arr.push(ob)
end
# remove the duplicates and sort on the users with the most followers,
sorted_influencers = arr.sort_by { |hsh| hsh[:followers_count] }
sorted_influencers.reverse!
sorted_influencers[0..9].to_s
end
I am trying to handle rate limits.
How to cache the json output to avoid rate limit exceeding?
Assuming you keep your very simple scenario, you could use a small custom class to store the information and provide thread-safe methods (it is not clear from your question where your problem exactly resides, but this one problem will arise anyway):
require 'json'
require 'sinatra'
require 'date'
require 'thread'
require 'twitter'
set :server, 'webrick'
set :haml, :format => :html5
class MyCache
def initialize()
#mutex = Mutex.new
#last_update = DateTime.new # by default, -4732 BC
#client = Twitter::REST::Client.new do |config|
config.consumer_key = ""
config.consumer_secret = ""
config.access_token = ""
config.access_token_secret = ""
end
end
def get_cache
#mutex.synchronize do
if DateTime.now - #last_update > 10.0 / (3600 * 24)
#last_update = DateTime.now
arr = []
retweeters = #client.retweeters_of(429627812459593728)
retweeters.each do |retweeter|
ob = {}
ob[:name] = retweeter.name
ob[:followers_count] = retweeter.followers_count
arr.push(ob)
end
# remove the duplicates and sort on the users with the most followers,
sorted_influencers = arr.sort_by { |hsh| hsh[:followers_count] }
sorted_influencers.reverse!
#cache = sorted_influencers[0..9].to_s
end
#cache
end
end
end
my_cache = MyCache.new
get '/' do
content_type :json
my_cache.get_cache
end
This version now includes everything needed. I use the #client to store the instance of the twitter client (I suppose it's reusable), also note how the whole code is inside the if statement, and at last we update #cache. If you are unfamiliar with Ruby, the value of a block is determined by its last expression, so when I write #cache alone it is as if I had written return #cache.
This is the Sinatra code that I wrote. All gems exist, the ruby files compiles perfectly but when i go to localhost:4567/ the sinatra app doesnt run. It takes me to the 'Sinatra doesnt know this ditty' page. What mistake am i making here? Is it a syntax issue? I've posted the main ruby file's code here others are just haml files thats all.
require 'bundler'
Bundler.setup(:default)
require 'sinatra'
require 'haml'
require 'twitter'
require 'oauth'
class MyTweetWeek < Sinatra::Base
set :haml, :format => :html5, :attr_wrapper => '"'
enable :sessions, :static, :raise_errors
set :public_dir, File.join(File.dirname(__FILE__), 'public')
get '/' do
haml :index
end
get '/login' do
request_token = consumer.get_request_token(:oauth_callback => ENV['OAUTH_CALLBACK'])
session[:request_token] = request_token.token
session[:request_token_secret] = request_token.secret
redirect request_token.authorize_url
end
get '/oauth_callback' do
request_token = OAuth::RequestToken.new(
consumer,
session[:request_token],
session[:request_token_secret]
)
session[:request_token] = session[:request_token_secret] = nil
access_token = request_token.get_access_token(:oauth_verifier => params[:oauth_verifier])
session[:access_token] = access_token.token
session[:access_secret] = access_token.secret
redirect '/resume'
end
get '/resume' do
redirect '/' unless authenticated?
today = Date.today #get today's date
monday = today - today.cwday + 1 #calculate Monday
search = Twitter::Search.new
#screen_name = client.verify_credentials.screen_name
#number_of_tweets = 0
#number_of_mentions = 0
results = search.from(#screen_name)
.since_date(monday)
.no_retweets
.per_page(100)
.fetch
#number_of_tweets += results.size
while search.next_page?
results = search.fetch_next_page
#number_of_tweets += results.size
end
search.clear
results = search.q("##{#screen_name.gsub('#', '')}")
.since_date(monday)
.no_retweets
.per_page(100)
.fetch
#number_of_mentions += results.size
while search.next_page?
results = search.fetch_next_page
#number_of_mentions += results.size
end
haml :resume
end
error Twitter::Error::Unauthorized do
redirect '/'
end
not_found do
haml :not_found
end
private
def consumer
#consumer ||= OAuth::Consumer.new(
ENV['CONSUMER_KEY'],
ENV['CONSUMER_SECRET'],
:site => "https://api.twitter.com"
)
end
def client
Twitter.configure do |config|
config.consumer_key = ENV['CONSUMER_KEY']
config.consumer_secret = ENV['CONSUMER_SECRET']
config.oauth_token = session[:access_token]
config.oauth_token_secret = session[:access_secret]
end
#client ||= Twitter::Client.new
end
def authenticated?
!session[:access_token].nil? && !session[:access_secret].nil?
end
end
As you have a modular app do you need to require "sinatra/base" rather than "sinatra"? See here
See Serving a Modular App and add the line run! if app_file == $0 at the end of the class. Also see DavB's answer.