idx int64 0 24.9k | question stringlengths 68 4.14k | target stringlengths 9 749 |
|---|---|---|
7,800 | def create_session! handle_token_error access = @strategy . authenticate ( @request . GET [ 'code' ] ) @request . session [ :redd_session ] = access . to_h rescue Errors :: TokenRetrievalError , Errors :: ResponseError => error @request . env [ 'redd.error' ] = error end | Store the access token and other details in the user s browser assigning any errors to the redd . error env variable . |
7,801 | def request ( verb , path , raw : false , params : { } , ** options ) ensure_access_is_valid api_params = { api_type : 'json' , raw_json : 1 } . merge ( params ) handle_retryable_errors do response = @rate_limiter . after_limit { super ( verb , path , params : api_params , ** options ) } response_error = @error_handler... | Makes a request ensuring not to break the rate limit by sleeping . |
7,802 | def hash_to_model ( klass_name , hash ) model_klass = if self . class . const_defined? ( "#{self.class}::#{klass_name}" ) self . class . const_get ( klass_name ) else self . class . const_set ( klass_name , Class . new ( HashModel ) ) end model_klass . new ( hash ) end | Convert a hash to an instance of nested model class |
7,803 | def save_data ( res ) if res . key? ( "storage" ) case res [ "storage" ] . value when "Ruby Hash" req = "rh_storage" storage = "RubyHashStorage" when "Tokyo Cabinet" req = "tc_storage" storage = "TCStorage" bnum = Calculate . get_bnum ( res ) bnum = 5000000 if bnum < 5000000 xmsiz = Calculate . get_xmsize_max ( res ) w... | make config . rb based on input data |
7,804 | def update_attributes! ( attributes ) @api . patch ( url , attributes . to_json ) attributes . each do | method_name , value | invoke_name = "#{override_raw_attributes[method_name] || method_name}=" if respond_to? ( invoke_name ) send ( invoke_name , value ) else AnsibleTowerClient . logger . warn ( "Unknown attribute/... | Persist changes passed in as a Hash and return a representation of that object to the caller . |
7,805 | def hash_to_model ( klass_name , hash ) model_klass = if self . class . const_defined? ( klass_name , false ) self . class . const_get ( klass_name ) else self . class . const_set ( klass_name , Class . new ( BaseModel ) ) end model_klass . new ( api , hash ) end | convert a hash to an instance of nested model class |
7,806 | def stats ( options = { } ) raise ArgumentError , '#stats requires a stats arg' unless options [ :stats ] raise ArgumentError , '#stats requires a group arg' unless options [ :group ] get '/stats' , options end | View statistics based on statType group season and organization . |
7,807 | def standings ( options = { } ) options [ :hydrate ] = 'team' unless options . key? ( :hydrate ) if options [ :leagues ] && ! options [ :leagueId ] league_ids = Leagues :: LEAGUES . values_at ( * options . delete ( :leagues ) ) options [ :leagueId ] = league_ids end options [ :leagueId ] = [ 103 , 104 ] unless Array ( ... | View standings for a league . |
7,808 | def all_star_ballot ( league_id , season = nil , options = { } ) options [ :season ] = season || Time . now . year get "/league/#{league_id}/allStarBallot" , options end | View All - Star Ballots per league . |
7,809 | def all_star_write_ins ( league_id , season = nil , options = { } ) options [ :season ] = season || Time . now . year get "/league/#{league_id}/allStarWriteIns" , options end | View All - Star Write - ins per league . |
7,810 | def all_star_final_vote ( league_id , season = nil , options = { } ) options [ :season ] = season || Time . now . year get "/league/#{league_id}/allStarFinalVote" , options end | View All - Star Final Vote per league . |
7,811 | def person ( person_ids , options = { } ) ids = Array ( person_ids ) result = get ( '/people' , options . merge ( personIds : ids ) ) . dig ( 'people' ) return result . first if ids . length == 1 result end | View one or more person s stats and biographical information . |
7,812 | def run_specs ( options = nil ) options ||= { } files = options . fetch ( :files , 'spec' ) rspec_options = options . fetch ( :options , '--color' ) gemfile = options . fetch ( :gemfile , Gemika :: Env . gemfile ) fatal = options . fetch ( :fatal , true ) runner = binary ( :gemfile => gemfile ) bundle_exec = options . ... | Runs the RSpec binary . |
7,813 | def configure_should_syntax if Env . gem? ( 'rspec' , '>= 2.11' ) configure do | config | config . expect_with ( :rspec ) { | c | c . syntax = [ :should , :expect ] } config . mock_with ( :rspec ) { | c | c . syntax = [ :should , :expect ] } end else end end | Configures RSpec so it allows the should syntax that works across all RSpec versions . |
7,814 | def adapter_config default_config = { } default_config [ 'database' ] = guess_database_name if Env . gem? ( 'pg' ) default_config [ 'adapter' ] = 'postgresql' default_config [ 'username' ] = 'postgres' if Env . travis? default_config [ 'password' ] = '' user_config = @yaml_config [ 'postgresql' ] || @yaml_config [ 'pos... | Returns a hash of ActiveRecord adapter options for the currently activated database gem . |
7,815 | def each ( & block ) @all_passed = true rows . each do | row | gemfile = row . gemfile if row . compatible_with_ruby? ( current_ruby ) @compatible_count += 1 print_title gemfile gemfile_passed = Env . with_gemfile ( gemfile , row , & block ) @all_passed &= gemfile_passed if gemfile_passed @results [ row ] = tint ( 'Suc... | Runs the given block for each matrix row that is compatible with the current Ruby . |
7,816 | def with_gemfile ( path , * args , & block ) @gemfile_changed = true @process_gemfile = ENV [ 'BUNDLE_GEMFILE' ] Bundler . with_clean_env do ENV [ 'BUNDLE_GEMFILE' ] = path block . call ( * args ) end ensure @gemfile_changed = false ENV [ 'BUNDLE_GEMFILE' ] = @process_gemfile end | Changes the gemfile to the given path runs the given block then resets the gemfile to its original path . |
7,817 | def gem? ( * args ) options = args . last . is_a? ( Hash ) ? args . pop : { } name , requirement_string = args if options [ :gemfile ] && ! process_gemfile? ( options [ :gemfile ] ) gem_in_gemfile? ( options [ :gemfile ] , name , requirement_string ) else gem_activated? ( name , requirement_string ) end end | Check if the given gem was activated by the current gemfile . It might or might not have been require d yet . |
7,818 | def predicates ( predicate , collection , klass , column_name , value ) case predicate when :between klass . arel_table [ column_name ] . between ( value . first .. value . last ) when :does_not_match klass . arel_table [ column_name ] . does_not_match ( "%#{value}%" ) when :does_not_match_all klass . arel_table [ colu... | Apply arel predicate on collection |
7,819 | def catalog ( opts = { } ) return nil unless catalog? opts [ :replace ] = true unless opts . key? ( :replace ) cat = Systemd :: Journal . catalog_for ( self [ :message_id ] ) opts [ :replace ] ? field_substitute ( cat ) : cat end | Returns the catalog message that this Journal Entry references if any . |
7,820 | def query_unique ( field ) results = [ ] Native . sd_journal_restart_unique ( @ptr ) rc = Native . sd_journal_query_unique ( @ptr , field . to_s . upcase ) raise JournalError , rc if rc < 0 while ( kvpair = enumerate_helper ( :sd_journal_enumerate_unique ) ) results << kvpair . last end results end | Get the list of unique values stored in the journal for the given field . If passed a block each possible value will be yielded . |
7,821 | def data_threshold size_ptr = FFI :: MemoryPointer . new ( :size_t , 1 ) if ( rc = Native . sd_journal_get_data_threshold ( @ptr , size_ptr ) ) < 0 raise JournalError , rc end size_ptr . read_size_t end | Get the maximum length of a data field that will be returned . Fields longer than this will be truncated . Default is 64K . |
7,822 | def download ( url , path ) if url . match ( FILE_URL ) FileUtils . cp ( url . sub ( FILE_URL , '' ) , path ) else File . open ( path , 'w+' ) do | file | Net :: HTTP . get_response ( URI ( url ) ) do | response | response . read_body do | chunk | file . write chunk end end end end path end | Download a file to the specified path . |
7,823 | def ` ( command ) result = super ( command ) exit_code = $? . to_i raise Error :: CommandFailed . new ( result , exit_code ) unless exit_code == 0 result end | Actions have a backticks command that raises a CommandFailed exception on failure so that processing doesn t just blithely continue . |
7,824 | def safe_filename ( url ) url = url . sub ( / \? \Z / , '' ) ext = File . extname ( url ) name = URI . unescape ( File . basename ( url ) ) . gsub ( / \- / , '-' ) . gsub ( / / , '-' ) File . basename ( name , ext ) . gsub ( '.' , '-' ) + ext end | Convert an unsafe URL into a filesystem - friendly filename . |
7,825 | def download_input return unless input_is_url? Dir . chdir ( @work_directory ) do @input_path = File . join ( @work_directory , safe_filename ( @input ) ) @file_name = File . basename ( @input_path , File . extname ( @input_path ) ) download ( @input , @input_path ) end end | If the input is a URL download the file before beginning processing . |
7,826 | def send_work_unit ( unit ) result = node [ '/work' ] . post ( :work_unit => unit . to_json ) unit . assign_to ( self , JSON . parse ( result . body ) [ 'pid' ] ) touch && true rescue RestClient :: RequestTimeout CloudCrowd . log "Node #{host} received RequestTimeout, removing it" destroy && false rescue RestClient :: ... | Dispatch a WorkUnit to this node . Places the node at back at the end of the rotation . If we fail to send the WorkUnit we consider the node to be down and remove this record freeing up all of its checked - out work units . If the Node responds that it s overloaded we mark it as busy . Returns true if the WorkUnit was ... |
7,827 | def fail ( output , time_taken ) tries = self . attempts + 1 return try_again if tries < CloudCrowd . config [ :work_unit_retries ] update_attributes ( { :status => FAILED , :node_record => nil , :worker_pid => nil , :attempts => tries , :output => output , :time => time_taken } ) job && job . check_for_completion end | Mark this unit as having failed . May attempt a retry . |
7,828 | def complete_work_unit ( result ) keep_trying_to "complete work unit" do data = base_params . merge ( { :status => 'succeeded' , :output => result } ) @node . central [ "/work/#{data[:id]}" ] . put ( data ) log "finished #{display_work_unit} in #{data[:time]} seconds" end end | A new Worker customizes itself to its WorkUnit at instantiation . Return output to the central server marking the WorkUnit done . |
7,829 | def fail_work_unit ( exception ) keep_trying_to "mark work unit as failed" do data = base_params . merge ( { :status => 'failed' , :output => { 'output' => exception . message } . to_json } ) @node . central [ "/work/#{data[:id]}" ] . put ( data ) log "failed #{display_work_unit} in #{data[:time]} seconds\n#{exception.... | Mark the WorkUnit failed returning the exception to central . |
7,830 | def keep_trying_to ( title ) begin yield rescue RestClient :: ResourceNotFound => e log "work unit ##{@unit['id']} doesn't exist. discarding..." rescue Exception => e log "failed to #{title} -- retry in #{@retry_wait} seconds" log e . message log e . backtrace sleep @retry_wait retry end end | We expect and require internal communication between the central server and the workers to succeed . If it fails for any reason log it and then keep trying the same request . |
7,831 | def run_work_unit begin result = nil action_class = CloudCrowd . actions [ @unit [ 'action' ] ] action = action_class . new ( @status , @unit [ 'input' ] , enhanced_unit_options , @node . asset_store ) Dir . chdir ( action . work_directory ) do result = case @status when PROCESSING then action . process when SPLITTING ... | Executes the WorkUnit by running the Action catching all exceptions as failures . We capture the thread so that we can kill it from the outside when exiting . |
7,832 | def run trap_signals log "starting #{display_work_unit}" if @unit [ 'options' ] [ 'benchmark' ] log ( "ran #{display_work_unit} in " + Benchmark . measure { run_work_unit } . to_s ) else run_work_unit end Process . exit! end | Run this worker inside of a fork . Attempts to exit cleanly . Wraps run_work_unit to benchmark the execution time if requested . |
7,833 | def trap_signals Signal . trap ( 'QUIT' ) { Process . exit! } Signal . trap ( 'INT' ) { Process . exit! } Signal . trap ( 'TERM' ) { Process . exit! } end | When signaled to exit make sure that the Worker shuts down without firing the Node s at_exit callbacks . |
7,834 | def start_server port = @options [ :port ] || 9173 daemonize = @options [ :daemonize ] ? '-d' : '' log_path = CloudCrowd . log_path ( 'server.log' ) pid_path = CloudCrowd . pid_path ( 'server.pid' ) rackup_path = File . expand_path ( "#{@options[:config_path]}/config.ru" ) FileUtils . mkdir_p ( CloudCrowd . log_path ) ... | Convenience command for quickly spinning up the central server . More sophisticated deployments load - balancing across multiple app servers should use the config . ru rackup file directly . This method will start a single Thin server . |
7,835 | def run_install ( install_path ) require 'fileutils' install_path ||= '.' FileUtils . mkdir_p install_path unless File . exists? ( install_path ) install_file "#{CC_ROOT}/config/config.example.yml" , "#{install_path}/config.yml" install_file "#{CC_ROOT}/config/config.example.ru" , "#{install_path}/config.ru" install_fi... | Install the required CloudCrowd configuration files into the specified directory or the current one . |
7,836 | def ensure_config return if @config_found found = CONFIG_FILES . all? { | f | File . exists? "#{@options[:config_path]}/#{f}" } found ? @config_dir = true : config_not_found end | Check for configuration files either in the current directory or in the CLOUD_CROWD_CONFIG environment variable . Exit if they re not found . |
7,837 | def install_file ( source , dest , is_dir = false ) if File . exists? ( dest ) print "#{dest} already exists. Overwrite it? (yes/no) " return unless [ 'y' , 'yes' , 'ok' ] . include? gets . chomp . downcase end is_dir ? FileUtils . cp_r ( source , dest ) : FileUtils . cp ( source , dest ) puts "installed #{dest}" unles... | Install a file and log the installation . If we re overwriting a file offer a chance to back out . |
7,838 | def check_for_completion return unless all_work_units_complete? set_next_status outs = gather_outputs_from_work_units return queue_for_workers ( [ outs ] ) if merging? if complete? update_attributes ( :outputs => outs , :time => time_taken ) CloudCrowd . log "Job ##{id} (#{action}) #{display_status}." unless ENV [ 'RAC... | After work units are marked successful we check to see if all of them have finished if so continue on to the next phase of the job . |
7,839 | def percent_complete return 99 if merging? return 100 if complete? unit_count = work_units . count return 100 if unit_count <= 0 ( work_units . complete . count / unit_count . to_f * 100 ) . round end | How complete is this Job? Unfortunately with the current processing sequence the percent_complete can pull a fast one and go backwards . This happens when there s a single large input that takes a long time to split and when it finally does it creates a whole swarm of work units . This seems unavoidable . |
7,840 | def as_json ( opts = { } ) atts = { 'id' => id , 'color' => color , 'status' => display_status , 'percent_complete' => percent_complete , 'work_units' => work_units . count , 'time_taken' => time_taken } atts [ 'outputs' ] = JSON . parse ( outputs ) if outputs atts [ 'email' ] = email if email atts end | A JSON representation of this job includes the statuses of its component WorkUnits as well as any completed outputs . |
7,841 | def gather_outputs_from_work_units units = self . work_units . complete outs = self . work_units . complete . map { | u | u . parsed_output } self . work_units . complete . destroy_all outs . to_json end | When the WorkUnits are all finished gather all their outputs together before removing them from the database entirely . Returns their merged JSON . |
7,842 | def queue_for_workers ( input = nil ) input ||= JSON . parse ( self . inputs ) input . each { | i | WorkUnit . start ( self , action , i , status ) } self end | When starting a new job or moving to a new stage split up the inputs into WorkUnits and queue them . Workers will start picking them up right away . |
7,843 | def start FileUtils . mkdir_p ( CloudCrowd . log_path ) if @daemon && ! File . exists? ( CloudCrowd . log_path ) @server = Thin :: Server . new ( '0.0.0.0' , @port , self , :signals => false ) @server . tag = 'cloud-crowd-node' @server . pid_file = CloudCrowd . pid_path ( 'node.pid' ) @server . log_file = CloudCrowd . ... | When creating a node specify the port it should run on . Starting up a Node registers with the central server and begins to listen for incoming WorkUnits . |
7,844 | def check_in ( critical = false ) @central [ "/node/#{@id}" ] . put ( :busy => @overloaded , :tag => @tag , :max_workers => CloudCrowd . config [ :max_workers ] , :enabled_actions => @enabled_actions . join ( ',' ) ) rescue RestClient :: Exception , Errno :: ECONNREFUSED CloudCrowd . log "Failed to connect to the centr... | Checking in with the central server informs it of the location and configuration of this Node . If it can t check - in there s no point in starting . |
7,845 | def free_memory case RUBY_PLATFORM when / / stats = ` ` @mac_page_size ||= stats . match ( SCRAPE_MAC_PAGE ) [ 1 ] . to_f / 1048576.0 stats . match ( SCRAPE_MAC_MEMORY ) [ 1 ] . to_f * @mac_page_size when / / ` ` . match ( SCRAPE_LINUX_MEMORY ) [ 1 ] . to_f / 1024.0 else raise NotImplementedError , "'min_free_memory' i... | The current amount of free memory in megabytes . |
7,846 | def monitor_system @monitor_thread = Thread . new do loop do was_overloaded = @overloaded @overloaded = overloaded? check_in if was_overloaded && ! @overloaded sleep MONITOR_INTERVAL end end end | Launch a monitoring thread that periodically checks the node s load average and the amount of free memory remaining . If we transition out of the overloaded state let central know . |
7,847 | def check_in_periodically @check_in_thread = Thread . new do loop do check_on_workers reply = "" 1 . upto ( 5 ) . each do | attempt_number | sleep CHECK_IN_INTERVAL * attempt_number reply = check_in if reply . nil? CloudCrowd . log "Failed on attempt ##{attempt_number} to check in with server" else break end end if rep... | If communication is interrupted for external reasons the central server will assume that the node has gone down . Checking in will let central know it s still online . |
7,848 | def trap_signals Signal . trap ( 'QUIT' ) { shut_down } Signal . trap ( 'INT' ) { shut_down } Signal . trap ( 'TERM' ) { shut_down } end | Trap exit signals in order to shut down cleanly . |
7,849 | def fetch ( api_request ) uri = api_request . to_uri response = Net :: HTTP . start ( uri . host , use_ssl : api_request . ssl? ) do | http | http . read_timeout = 5 http . open_timeout = 5 http . get uri . request_uri , REQUEST_HEADERS end handle_response ( api_request , response ) rescue Timeout :: Error => e ErrorRe... | Perform API request ; return hash with html content |
7,850 | def live_response if response = api_client . fetch ( @api_request ) cache . write ( @api_request . cache_key , response ) build_response ( response ) end end | Return response from API and write to cache |
7,851 | def parse_params ( params ) args = params . split ( / \s / ) . map ( & :strip ) invalid_args! ( args ) unless args . any? if args [ 0 ] . to_s == OEMBED_ARG arguments_deprecation_warning ( args ) args . shift end url , * api_args = args ApiRequest . new ( url , parse_args ( api_args ) ) end | Return an ApiRequest with the url and arguments |
7,852 | def enforce_contracts ( contracts ) outcome = contracts . call ( context ) unless outcome . success? contract . consequences . each do | handler | instance_exec ( outcome . breaches , & handler ) end end end | Checks for a breach of contract and applies consequences for a breach |
7,853 | def remote ( endpoint , request_args = scope_key_hash ) response = remote_call ( endpoint , request_args ) assign_attributes_from_rpc ( response ) success? end | Executes a remote call on the current object and serializes it s attributes and errors from the response . |
7,854 | def read_attribute ( name ) name = name . to_s if respond_to? ( name ) attribute ( name ) else raise :: ActiveRemote :: UnknownAttributeError , "unknown attribute: #{name}" end end | Read attribute from the attributes hash |
7,855 | def write_attribute ( name , value ) name = name . to_s if respond_to? ( "#{name}=" ) __send__ ( "attribute=" , name , value ) else raise :: ActiveRemote :: UnknownAttributeError , "unknown attribute: #{name}" end end | Update an attribute in the attributes hash |
7,856 | def add_errors ( errors ) errors . each do | error | if error . respond_to? ( :message ) self . errors . add ( error . field , error . message ) elsif error . respond_to? ( :messages ) error . messages . each do | message | self . errors . add ( error . field , message ) end end end end | Add the given errors to our internal errors list |
7,857 | def cache_key case when new_record? then "#{self.class.name.underscore}/new" when :: ActiveRemote . config . default_cache_key_updated_at? && ( timestamp = self [ :updated_at ] ) then timestamp = timestamp . utc . to_s ( self . class . cache_timestamp_format ) "#{self.class.name.underscore}/#{self.to_param}-#{timestamp... | Returns a cache key that can be used to identify this record . |
7,858 | def save_as ( target_name = nil , overwrite : false , resume : true , & block ) target_name ||= @name tmpfile = "#{target_name}.incomplete" return if ! overwrite && File . exist? ( target_name ) if resume && File . size ( tmpfile ) > 0 from = File . size ( tmpfile ) len = @size - from fmode = 'ab' headers = { 'Range' :... | Saves current remote file as local file . |
7,859 | def set_mtime ( time ) attempt = 0 OneDriveFile . new ( @od , @od . request ( api_path , { fileSystemInfo : { lastModifiedDateTime : time . utc . iso8601 } } , :patch ) ) rescue sleep 10 attempt += 1 retry if attempt <= 3 end | Change last modified time for a remote file . |
7,860 | def request ( uri , data = nil , verb = :post ) @logger . info ( uri ) if @logger auth_check query = { path : File . join ( 'v1.0/me/' , URI . escape ( uri ) ) , headers : { 'Authorization' : "Bearer #{@access_token.token}" } } if data query [ :body ] = JSON . generate ( data ) query [ :headers ] [ 'Content-Type' ] = '... | Instanciates with app id and secret . Issues requests to API endpoint . |
7,861 | def get_child ( path ) children . find { | child | child . name == path } || OneDrive404 . new end | Get a child object by name inside current directory . |
7,862 | def mkdir ( name ) return self if name == '.' name = name [ 1 .. - 1 ] if name [ 0 ] == '/' newdir , * remainder = name . split ( '/' ) subdir = get ( newdir ) unless subdir . dir? result = @od . request ( "#{api_path}/children" , name : newdir , folder : { } , '@microsoft.graph.conflictBehavior' : 'rename' ) subdir = ... | Recursively creates empty directories . |
7,863 | def upload_simple ( filename , overwrite : , target_name : ) target_file = get ( target_name ) exist = target_file . file? return if exist && ! overwrite path = nil if exist path = "#{target_file.api_path}/content" else path = "#{api_path}:/#{target_name}:/content" end query = { path : File . join ( 'v1.0/me/' , path )... | Uploads a local file into current remote directory using simple upload mode . |
7,864 | def save ( output_path ) output_path = File . expand_path ( output_path ) create_epub do mimetype = Zip :: ZipOutputStream :: open ( output_path ) do | os | os . put_next_entry ( "mimetype" , nil , nil , Zip :: ZipEntry :: STORED , Zlib :: NO_COMPRESSION ) os << "application/epub+zip" end zipfile = Zip :: ZipFile . ope... | Save as OCF |
7,865 | def to_xml out = "" builder = Builder :: XmlMarkup . new ( :target => out , :indent => 2 ) builder . instruct! build_xml ( builder ) out end | Convert to xml of container item |
7,866 | def convert_to_xml_attributes ( hash ) result = { } hash . each do | k , v | key = k . to_s . gsub ( '_' , '-' ) . to_sym result [ key ] = v end result end | Convert options for xml attributes |
7,867 | def witness_commitment return nil unless coinbase_tx? outputs . each do | output | commitment = output . script_pubkey . witness_commitment return commitment if commitment end nil end | get the witness commitment of coinbase tx . if this tx does not coinbase or not have commitment return nil . |
7,868 | def serialize_old_format buf = [ version ] . pack ( 'V' ) buf << Bitcoin . pack_var_int ( inputs . length ) << inputs . map ( & :to_payload ) . join buf << Bitcoin . pack_var_int ( outputs . length ) << outputs . map ( & :to_payload ) . join buf << [ lock_time ] . pack ( 'V' ) buf end | serialize tx with old tx format |
7,869 | def standard? return false if version > MAX_STANDARD_VERSION return false if weight > MAX_STANDARD_TX_WEIGHT inputs . each do | i | return false if i . script_sig . size > 1650 return false unless i . script_sig . push_only? end data_count = 0 outputs . each do | o | return false unless o . script_pubkey . standard? da... | check this tx is standard . |
7,870 | def sighash_for_input ( input_index , output_script , hash_type : SIGHASH_TYPE [ :all ] , sig_version : :base , amount : nil , skip_separator_index : 0 ) raise ArgumentError , 'input_index must be specified.' unless input_index raise ArgumentError , 'does not exist input corresponding to input_index.' if input_index >=... | get signature hash |
7,871 | def verify_input_sig ( input_index , script_pubkey , amount : nil , flags : STANDARD_SCRIPT_VERIFY_FLAGS ) script_sig = inputs [ input_index ] . script_sig has_witness = inputs [ input_index ] . has_witness? if script_pubkey . p2sh? flags << SCRIPT_VERIFY_P2SH redeem_script = Script . parse_from_payload ( script_sig . ... | verify input signature . |
7,872 | def sighash_for_legacy ( index , script_code , hash_type ) ins = inputs . map . with_index do | i , idx | if idx == index i . to_payload ( script_code . delete_opcode ( Bitcoin :: Opcodes :: OP_CODESEPARATOR ) ) else case hash_type & 0x1f when SIGHASH_TYPE [ :none ] , SIGHASH_TYPE [ :single ] i . to_payload ( Bitcoin :... | generate sighash with legacy format |
7,873 | def verify_input_sig_for_legacy ( input_index , script_pubkey , flags ) script_sig = inputs [ input_index ] . script_sig checker = Bitcoin :: TxChecker . new ( tx : self , input_index : input_index ) interpreter = Bitcoin :: ScriptInterpreter . new ( checker : checker , flags : flags ) interpreter . verify_script ( scr... | verify input signature for legacy tx . |
7,874 | def verify_input_sig_for_witness ( input_index , script_pubkey , amount , flags ) flags |= SCRIPT_VERIFY_WITNESS flags |= SCRIPT_VERIFY_WITNESS_PUBKEYTYPE checker = Bitcoin :: TxChecker . new ( tx : self , input_index : input_index , amount : amount ) interpreter = Bitcoin :: ScriptInterpreter . new ( checker : checker... | verify input signature for witness tx . |
7,875 | def ext_pubkey k = ExtPubkey . new k . depth = depth k . number = number k . parent_fingerprint = parent_fingerprint k . chain_code = chain_code k . pubkey = key . pubkey k . ver = priv_ver_to_pub_ver k end | get ExtPubkey from priv_key |
7,876 | def to_payload version . htb << [ depth ] . pack ( 'C' ) << parent_fingerprint . htb << [ number ] . pack ( 'N' ) << chain_code << [ 0x00 ] . pack ( 'C' ) << key . priv_key . htb end | serialize extended private key |
7,877 | def to_base58 h = to_payload . bth hex = h + Bitcoin . calc_checksum ( h ) Base58 . encode ( hex ) end | Base58 encoded extended private key |
7,878 | def derive ( number , harden = false ) number += HARDENED_THRESHOLD if harden new_key = ExtKey . new new_key . depth = depth + 1 new_key . number = number new_key . parent_fingerprint = fingerprint if number > ( HARDENED_THRESHOLD - 1 ) data = [ 0x00 ] . pack ( 'C' ) << key . priv_key . htb << [ number ] . pack ( 'N' )... | derive new key |
7,879 | def priv_ver_to_pub_ver case version when Bitcoin . chain_params . bip49_privkey_p2wpkh_p2sh_version Bitcoin . chain_params . bip49_pubkey_p2wpkh_p2sh_version when Bitcoin . chain_params . bip84_privkey_p2wpkh_version Bitcoin . chain_params . bip84_pubkey_p2wpkh_version else Bitcoin . chain_params . extended_pubkey_ver... | convert privkey version to pubkey version |
7,880 | def to_payload version . htb << [ depth ] . pack ( 'C' ) << parent_fingerprint . htb << [ number ] . pack ( 'N' ) << chain_code << pub . htb end | serialize extended pubkey |
7,881 | def derive ( number ) new_key = ExtPubkey . new new_key . depth = depth + 1 new_key . number = number new_key . parent_fingerprint = fingerprint raise 'hardened key is not support' if number > ( HARDENED_THRESHOLD - 1 ) data = pub . htb << [ number ] . pack ( 'N' ) l = Bitcoin . hmac_sha512 ( chain_code , data ) left =... | derive child key |
7,882 | def p2pkh? return false unless chunks . size == 5 [ OP_DUP , OP_HASH160 , OP_EQUALVERIFY , OP_CHECKSIG ] == ( chunks [ 0 .. 1 ] + chunks [ 3 .. 4 ] ) . map ( & :ord ) && chunks [ 2 ] . bytesize == 21 end | whether this script is a P2PKH format script . |
7,883 | def push_only? chunks . each do | c | return false if ! c . opcode . nil? && c . opcode > OP_16 end true end | whether data push only script which dose not include other opcode |
7,884 | def witness_program? return false if size < 4 || size > 42 || chunks . size < 2 opcode = chunks [ 0 ] . opcode return false if opcode != OP_0 && ( opcode < OP_1 || opcode > OP_16 ) return false unless chunks [ 1 ] . pushdata? if size == ( chunks [ 1 ] [ 0 ] . unpack ( 'C' ) . first + 2 ) program_size = chunks [ 1 ] . p... | A witness program is any valid Script that consists of a 1 - byte push opcode followed by a data push between 2 and 40 bytes . |
7,885 | def witness_commitment return nil if ! op_return? || op_return_data . bytesize < 36 buf = StringIO . new ( op_return_data ) return nil unless buf . read ( 4 ) . bth == WITNESS_COMMITMENT_HEADER buf . read ( 32 ) . bth end | get witness commitment |
7,886 | def to_script_code ( skip_separator_index = 0 ) payload = to_payload if p2wpkh? payload = Script . to_p2pkh ( chunks [ 1 ] . pushed_data . bth ) . to_payload elsif skip_separator_index > 0 payload = subscript_codeseparator ( skip_separator_index ) end Bitcoin . pack_var_string ( payload ) end | If this script is witness program return its script code otherwise returns the self payload . ScriptInterpreter does not use this . |
7,887 | def witness_data version = opcode_to_small_int ( chunks [ 0 ] . opcode ) program = chunks [ 1 ] . pushed_data [ version , program ] end | get witness version and witness program |
7,888 | def << ( obj ) if obj . is_a? ( Integer ) push_int ( obj ) elsif obj . is_a? ( String ) append_data ( obj ) elsif obj . is_a? ( Array ) obj . each { | o | self . << o } self end end | append object to payload |
7,889 | def append_opcode ( opcode ) opcode = Opcodes . small_int_to_opcode ( opcode ) if - 1 <= opcode && opcode <= 16 raise ArgumentError , "specified invalid opcode #{opcode}." unless Opcodes . defined? ( opcode ) chunks << opcode . chr self end | append opcode to payload |
7,890 | def append_data ( data ) data = Encoding :: ASCII_8BIT == data . encoding ? data : data . htb chunks << Bitcoin :: Script . pack_pushdata ( data ) self end | append data to payload with pushdata opcode |
7,891 | def include? ( item ) chunk_item = if item . is_a? ( Integer ) item . chr elsif item . is_a? ( String ) data = Encoding :: ASCII_8BIT == item . encoding ? item : item . htb Bitcoin :: Script . pack_pushdata ( data ) end return false unless chunk_item chunks . include? ( chunk_item ) end | Check the item is in the chunk of the script . |
7,892 | def find_and_delete ( subscript ) raise ArgumentError , 'subscript must be Bitcoin::Script' unless subscript . is_a? ( Script ) return self if subscript . chunks . empty? buf = [ ] i = 0 result = Script . new chunks . each do | chunk | sub_chunk = subscript . chunks [ i ] if chunk . start_with? ( sub_chunk ) if chunk =... | removes chunks matching subscript byte - for - byte and returns as a new object . |
7,893 | def subscript_codeseparator ( separator_index ) buf = [ ] process_separator_index = 0 chunks . each { | chunk | buf << chunk if process_separator_index == separator_index if chunk . ord == OP_CODESEPARATOR && process_separator_index < separator_index process_separator_index += 1 end } buf . join end | Returns a script that deleted the script before the index specified by separator_index . |
7,894 | def p2pkh_addr return nil unless p2pkh? hash160 = chunks [ 2 ] . pushed_data . bth return nil unless hash160 . htb . bytesize == 20 Bitcoin . encode_base58_address ( hash160 , Bitcoin . chain_params . address_version ) end | generate p2pkh address . if script dose not p2pkh return nil . |
7,895 | def p2sh_addr return nil unless p2sh? hash160 = chunks [ 1 ] . pushed_data . bth return nil unless hash160 . htb . bytesize == 20 Bitcoin . encode_base58_address ( hash160 , Bitcoin . chain_params . p2sh_version ) end | generate p2sh address . if script dose not p2sh return nil . |
7,896 | def bech32_addr segwit_addr = Bech32 :: SegwitAddr . new segwit_addr . hrp = Bitcoin . chain_params . bech32_hrp segwit_addr . script_pubkey = to_payload . bth segwit_addr . addr end | return bech32 address for payload |
7,897 | def to_entropy ( words ) word_master = load_words mnemonic = words . map do | w | index = word_master . index ( w . downcase ) raise IndexError , 'word not found in words list.' unless index index . to_s ( 2 ) . rjust ( 11 , '0' ) end . join entropy = mnemonic . slice ( 0 , ( mnemonic . length * 32 ) / 33 ) checksum = ... | generate entropy from mnemonic word |
7,898 | def to_mnemonic ( entropy ) raise ArgumentError , 'entropy is empty.' if entropy . nil? || entropy . empty? e = entropy . htb . unpack ( 'B*' ) . first seed = e + checksum ( e ) mnemonic_index = seed . chars . each_slice ( 11 ) . map { | i | i . join . to_i ( 2 ) } word_master = load_words mnemonic_index . map { | i | ... | generate mnemonic words from entropy . |
7,899 | def to_seed ( mnemonic , passphrase : '' ) to_entropy ( mnemonic ) OpenSSL :: PKCS5 . pbkdf2_hmac ( mnemonic . join ( ' ' ) . downcase , 'mnemonic' + passphrase , 2048 , 64 , OpenSSL :: Digest :: SHA512 . new ) . bth end | generate seed from mnemonic if mnemonic protected with passphrase specify that passphrase . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.